#include "taskmanagerapp.h"

#include <QtWidgets> // 包含常用的控件和布局类
#include <QNetworkRequest>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QMessageBox>
#include <QUrl>
#include <QVariant> // 用于在 QListWidgetItem 中存储数据

TaskManagerApp::TaskManagerApp(QWidget *parent)
    : QMainWindow(parent), selectedTaskId(std::nullopt) // 初始化可选值
{
    networkManager = new QNetworkAccessManager(this);
    setupUi();
    setupConnections();
    showStatus("准备就绪。请确保 RESTful API 正在运行。");
    loadTasks(); // 初始加载
}

TaskManagerApp::~TaskManagerApp()
{
    // Qt 自动处理子对象删除 (networkManager, widgets)
}

void TaskManagerApp::setupUi()
{
    setWindowTitle("任务管理器");
    // setGeometry(100, 100, 700, 500); // 可选：设置初始大小和位置

    // --- 中央控件和主布局 ---
    QWidget *centralWidget = new QWidget(this);
    this->setCentralWidget(centralWidget);
    QHBoxLayout *mainLayout = new QHBoxLayout(centralWidget); // 主水平布局

    // --- 左侧：任务列表 ---
    QGroupBox *listGroupBox = new QGroupBox("任务列表");
    QVBoxLayout *listLayout = new QVBoxLayout(listGroupBox);
    taskListWidget = new QListWidget();
    taskListWidget->setAlternatingRowColors(true); // 提高可读性
    listLayout->addWidget(taskListWidget);
    mainLayout->addWidget(listGroupBox, 1); // 伸展因子 1

    // --- 右侧：详情和控件 ---
    QWidget *detailsContainer = new QWidget();
    QVBoxLayout *detailsMainLayout = new QVBoxLayout(detailsContainer);
    mainLayout->addWidget(detailsContainer, 2); // 伸展因子 2 (更宽)

    // --- 表单框架 ---
    QGroupBox *formGroupBox = new QGroupBox("任务详情");
    QFormLayout *formLayout = new QFormLayout(formGroupBox); // 适用于标签-字段对
    formLayout->setRowWrapPolicy(QFormLayout::WrapLongRows);

    idLabelValue = new QLabel("-");
    titleLineEdit = new QLineEdit();
    descLineEdit = new QLineEdit();
    statusComboBox = new QComboBox();
    statusComboBox->addItems({"todo", "in_progress", "done"});
    statusComboBox->setCurrentIndex(-1); // 无初始选择
    dueDateLineEdit = new QLineEdit();
    dueDateLineEdit->setPlaceholderText("可选, 格式: " + QDateTime::currentDateTime().toString(dateTimeFormatApi)); // 显示示例格式
    createdLabelValue = new QLabel("-");
    updatedLabelValue = new QLabel("-");

    formLayout->addRow("ID:", idLabelValue);
    formLayout->addRow("标题:", titleLineEdit);
    formLayout->addRow("描述:", descLineEdit);
    formLayout->addRow("状态:", statusComboBox);
    formLayout->addRow("截止日期:", dueDateLineEdit);
    formLayout->addRow("创建时间:", createdLabelValue);
    formLayout->addRow("更新时间:", updatedLabelValue);

    detailsMainLayout->addWidget(formGroupBox);

    // --- 按钮框架 ---
    QWidget *buttonContainer = new QWidget();
    QHBoxLayout *buttonLayout = new QHBoxLayout(buttonContainer);
    buttonLayout->setContentsMargins(0, 0, 0, 0); // 移除边距（如果需要）

    refreshButton = new QPushButton("刷新列表");
    newButton = new QPushButton("新建任务");
    saveButton = new QPushButton("保存任务");
    deleteButton = new QPushButton("删除任务");

    saveButton->setEnabled(false); // 初始禁用
    deleteButton->setEnabled(false); // 初始禁用

    buttonLayout->addWidget(refreshButton);
    buttonLayout->addWidget(newButton);
    buttonLayout->addWidget(saveButton);
    buttonLayout->addWidget(deleteButton);
    buttonLayout->addStretch(); // 将按钮推到左侧

    detailsMainLayout->addWidget(buttonContainer);
    detailsMainLayout->addStretch(); // 将表单和按钮推到顶部

    // --- 状态栏 ---
    mainStatusBar = this->statusBar();
    mainStatusBar->showMessage("正在尝试加载任务...");
}

void TaskManagerApp::setupConnections()
{
    // UI 信号 -> 槽
    connect(taskListWidget, &QListWidget::currentItemChanged, this, &TaskManagerApp::onTaskSelectionChanged);
    connect(refreshButton, &QPushButton::clicked, this, &TaskManagerApp::loadTasks);
    connect(newButton, &QPushButton::clicked, this, &TaskManagerApp::prepareNewTask);
    connect(saveButton, &QPushButton::clicked, this, &TaskManagerApp::saveTask);
    connect(deleteButton, &QPushButton::clicked, this, &TaskManagerApp::deleteTask);

    // 网络管理器信号 -> 槽 (通用处理程序方法)
    // 我们将在发出请求的函数中连接特定的回复信号。
}


void TaskManagerApp::showStatus(const QString &message, int timeout)
{
    if (mainStatusBar) {
        mainStatusBar->showMessage(message, timeout);
    }
    qDebug() << "状态:" << message;
}


void TaskManagerApp::showError(const QString &title, const QString &message)
{
    QMessageBox::critical(this, title, message);
    qDebug() << "错误 -" << title << ":" << message;
}


void TaskManagerApp::clearForm(bool clearId)
{
    if (clearId) {
        idLabelValue->setText("-");
    }
    titleLineEdit->clear();
    descLineEdit->clear();
    statusComboBox->setCurrentIndex(-1); // 清除选择
    dueDateLineEdit->clear();
    createdLabelValue->setText("-");
    updatedLabelValue->setText("-");
    titleLineEdit->setFocus(); // 设置焦点到标题
}


void TaskManagerApp::setFormEnabled(bool enabled)
{
    // 启用/禁用输入字段
    titleLineEdit->setEnabled(enabled);
    descLineEdit->setEnabled(enabled);
    statusComboBox->setEnabled(enabled);
    dueDateLineEdit->setEnabled(enabled);
    // ID、创建时间、更新时间等标签通常不禁用
}


void TaskManagerApp::loadTasks()
{
    showStatus("正在加载任务...");
    taskListWidget->clear();
    tasksData.clear();
    selectedTaskId = std::nullopt;
    clearForm();
    saveButton->setEnabled(false);
    saveButton->setText("保存任务");
    deleteButton->setEnabled(false);
    setFormEnabled(false); // 加载时禁用表单


    QNetworkRequest request(QUrl(apiBaseUrl + "/tasks"));
    QNetworkReply *reply = networkManager->get(request);
    // 将特定回复的 finished 信号连接到处理程序槽
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        handleTasksFetched(reply);
    });
}


void TaskManagerApp::handleTasksFetched(QNetworkReply *reply)
{
    // 确保稍后删除回复对象
    reply->deleteLater();

    if (reply->error() == QNetworkReply::NoError) {
        QByteArray responseData = reply->readAll();
        QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData);

        if (!jsonDoc.isNull() && jsonDoc.isArray()) {
            updateTaskList(jsonDoc.array());
            showStatus(QString("已加载 %1 个任务。").arg(jsonDoc.array().size()));
        } else {
            showError("API 错误", "从 API 接收到无效的任务列表数据格式。");
            showStatus("加载任务失败。");
        }
    } else {
        handleNetworkError(reply);
        showStatus("加载任务失败。请检查 API 连接。");
    }
    setFormEnabled(false); // 在选择/新建任务之前保持表单禁用状态
}


void TaskManagerApp::updateTaskList(const QJsonArray &tasks)
{
    taskListWidget->clear(); // 清除之前的项目
    tasksData.clear();       // 清除缓存

    // 将 QJsonArray 转换为 QList<QJsonObject> 以进行排序
    QList<QJsonObject> taskList;
    for (const QJsonValue &value : tasks) {
        if (value.isObject()) {
            taskList.append(value.toObject());
        }
    }

    // 按 ID 对任务进行排序（可选，但良好实践）
    std::sort(taskList.begin(), taskList.end(), [](const QJsonObject &a, const QJsonObject &b) {
        return a.value("id").toInt(0) < b.value("id").toInt(0);
    });


    // 填充列表控件和缓存
    for (const QJsonObject &task : taskList) {
        int taskId = task.value("id").toInt(-1);
        QString title = task.value("title").toString("无标题");
        if (taskId != -1) {
            QString displayText = QString("%1: %2").arg(taskId).arg(title);
            QListWidgetItem *item = new QListWidgetItem(displayText, taskListWidget);
            item->setData(Qt::UserRole, taskId); // 在项目中存储 ID
            tasksData.insert(taskId, task);      // 添加到缓存
        }
    }
}


void TaskManagerApp::onTaskSelectionChanged()
{
    QListWidgetItem *currentItem = taskListWidget->currentItem();
    if (!currentItem) {
        selectedTaskId = std::nullopt;
        clearForm();
        saveButton->setEnabled(false);
        saveButton->setText("保存任务");
        deleteButton->setEnabled(false);
        setFormEnabled(false);
        return;
    }

    bool ok;
    int taskId = currentItem->data(Qt::UserRole).toInt(&ok);

    if (!ok) {
        showError("选择错误", "无法从所选项中确定任务 ID。");
        selectedTaskId = std::nullopt;
        clearForm();
        saveButton->setEnabled(false);
        deleteButton->setEnabled(false);
        setFormEnabled(false);
        return;
    }

    selectedTaskId = taskId;

    // 首先尝试从缓存中填充
    if (tasksData.contains(taskId)) {
        populateForm(tasksData.value(taskId));
        saveButton->setText("更新任务");
        saveButton->setEnabled(true);
        deleteButton->setEnabled(true);
        setFormEnabled(true);
        showStatus(QString("已选择任务 ID: %1").arg(taskId));
    } else {
        // 如果不在缓存中（通常不应该发生在当前加载逻辑下，但良好的回退）
        showStatus(QString("正在获取任务 ID: %1 的详情...").arg(taskId));
        clearForm(false); // 保留 ID 标签（可能），清除其余部分
        setFormEnabled(false); // 获取详细信息时禁用表单
        saveButton->setEnabled(false);
        deleteButton->setEnabled(false);

        QNetworkRequest request(QUrl(QString("%1/tasks/%2").arg(apiBaseUrl).arg(taskId)));
        QNetworkReply *reply = networkManager->get(request);
        connect(reply, &QNetworkReply::finished, this, [this, reply]() {
            handleTaskDetailsFetched(reply);
        });
    }
}


void TaskManagerApp::handleTaskDetailsFetched(QNetworkReply *reply)
{
    reply->deleteLater();

    if (!selectedTaskId.has_value()) return; // 选择可能已更改

    int currentSelectedId = selectedTaskId.value();

    if (reply->error() == QNetworkReply::NoError) {
        QByteArray responseData = reply->readAll();
        QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData);

        if (!jsonDoc.isNull() && jsonDoc.isObject()) {
            QJsonObject task = jsonDoc.object();
            int fetchedId = task.value("id").toInt(-1);
            // 确保获取的详细信息对应于*当前*选定的任务
            if (fetchedId == currentSelectedId) {
                tasksData.insert(fetchedId, task); // 更新缓存
                populateForm(task);
                saveButton->setText("更新任务");
                saveButton->setEnabled(true);
                deleteButton->setEnabled(true);
                setFormEnabled(true);
                showStatus(QString("已选择任务 ID: %1").arg(currentSelectedId));
            } else {
                // 响应是针对先前选择的项目，忽略或适当地处理
                qDebug() << "收到任务的详细信息" << fetchedId << "但当前选择的是" << currentSelectedId;
            }
        } else {
            if (selectedTaskId.has_value() && selectedTaskId.value() == currentSelectedId) { // 再次检查选择是否更改
                showError("API 错误", "接收到无效的任务详细信息数据格式。");
                showStatus(QString("无法加载任务 ID: %1 的详情。").arg(currentSelectedId));
                // 可选择清除表单或重置选择
                prepareNewTask(); // 进入干净状态
            }
        }
    } else {
        if (selectedTaskId.has_value() && selectedTaskId.value() == currentSelectedId) {
            handleNetworkError(reply);
            showStatus(QString("无法加载任务 ID: %1 的详情。").arg(currentSelectedId));
            prepareNewTask(); // 进入干净状态
        }
    }
}


void TaskManagerApp::populateForm(const QJsonObject &task)
{
    idLabelValue->setText(QString::number(task.value("id").toInt()));
    titleLineEdit->setText(task.value("title").toString());
    descLineEdit->setText(task.value("description").toString());

    // 设置状态组合框
    QString status = task.value("status").toString("todo");
    int index = statusComboBox->findText(status, Qt::MatchFixedString);
    statusComboBox->setCurrentIndex(index >= 0 ? index : 0); // 如果未找到，则默认为第一个项目


    // 处理 due_date（API 中可能为空或空字符串）
    QJsonValue dueDateVal = task.value("due_date");
    dueDateLineEdit->setText(dueDateVal.isNull() ? "" : dueDateVal.toString());

    createdLabelValue->setText(formatDateTime(task.value("created_at").toString()));
    updatedLabelValue->setText(formatDateTime(task.value("updated_at").toString()));
}


QString TaskManagerApp::formatDateTime(const QString &dateTimeString)
{
    if (dateTimeString.isEmpty()) {
        return "-";
    }
    // Qt::ISODateWithMs 可以解析 "2023-10-27T10:30:00.123Z" 之类的格式
    QDateTime dt = QDateTime::fromString(dateTimeString, dateTimeFormatApi);
    if (dt.isValid()) {
        // 如果是 UTC ('Z')，则转换为本地时间以进行显示
        if (dateTimeString.endsWith('Z')) {
            dt = dt.toLocalTime();
        }
        return dt.toString(dateTimeFormatDisplay);
    } else {
        // 如果第一次尝试失败，请尝试解析不带毫秒的日期时间字符串
        dt = QDateTime::fromString(dateTimeString, Qt::ISODate);
        if (dt.isValid()) {
            if (dateTimeString.endsWith('Z')) {
                dt = dt.toLocalTime();
            }
            return dt.toString(dateTimeFormatDisplay);
        }
        qWarning() << "无法解析日期时间字符串:" << dateTimeString;
        return dateTimeString; // 如果解析失败，则返回原始字符串
    }
}


void TaskManagerApp::prepareNewTask()
{
    taskListWidget->clearSelection(); // 取消选择列表中的项目
    selectedTaskId = std::nullopt;
    clearForm();
    statusComboBox->setCurrentText("todo"); // 新任务的默认状态
    saveButton->setText("创建任务");
    saveButton->setEnabled(true);
    deleteButton->setEnabled(false);
    setFormEnabled(true);
    showStatus("请输入新任务的详细信息。");
    titleLineEdit->setFocus();
}


QJsonObject TaskManagerApp::getFormData()
{
    QJsonObject taskData;
    QString title = titleLineEdit->text().trimmed();
    QString description = descLineEdit->text().trimmed();
    QString status = statusComboBox->currentText();
    QString dueDate = dueDateLineEdit->text().trimmed();

    taskData["title"] = title;
    taskData["description"] = description;
    taskData["status"] = status.isEmpty() ? "todo" : status; // 如果为空，则默认为 todo


    // 仅在 due_date 不为空时才包含它
    if (!dueDate.isEmpty()) {
        // 可选：基本验证或格式警告
        QDateTime dt = QDateTime::fromString(dueDate, dateTimeFormatApi);
        if (!dt.isValid()) {
            // 也尝试 ISODate 格式
            dt = QDateTime::fromString(dueDate, Qt::ISODate);
        }

        if (!dt.isValid()) {
            QString warningText = QString("截止日期 '%1' 似乎不符合预期的 ISO 格式 (例如: %2)。\n\n确定要继续吗？ (API 可能会拒绝)")
                                      .arg(dueDate, QDateTime::currentDateTime().toString(dateTimeFormatApi));
            if (QMessageBox::warning(this, "日期格式警告", warningText, QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::No)
            {
                dueDateLineEdit->setFocus();
                return QJsonObject(); // 返回空对象以指示验证失败
            }
        }
        // 按原样发送字符串，让 API 完全验证
        taskData["due_date"] = dueDate;
    } else {
        // 发送 null 或省略？取决于 API。如果为空，我们发送 null。
        // 如果 API 期望该字段为空时不存在，请将其删除。
        taskData["due_date"] = QJsonValue(); // 表示 JSON null
    }

    return taskData;
}


void TaskManagerApp::saveTask()
{
    QString title = titleLineEdit->text().trimmed();
    if (title.isEmpty()) {
        showError("验证错误", "任务标题不能为空。");
        titleLineEdit->setFocus();
        return;
    }

    QJsonObject taskData = getFormData();
    if (taskData.isEmpty()) { // 检查 getFormData 是否指示验证失败
        return;
    }


    QNetworkRequest request;
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
    QByteArray jsonData = QJsonDocument(taskData).toJson();

    if (!selectedTaskId.has_value()) { // 创建新任务
        showStatus("正在创建新任务...");
        request.setUrl(QUrl(apiBaseUrl + "/tasks"));
        QNetworkReply *reply = networkManager->post(request, jsonData);
        connect(reply, &QNetworkReply::finished, this, [this, reply]() {
            handleTaskCreated(reply);
        });

    } else { // 更新现有任务
        int taskId = selectedTaskId.value();
        showStatus(QString("正在更新任务 ID: %1...").arg(taskId));
        request.setUrl(QUrl(QString("%1/tasks/%2").arg(apiBaseUrl).arg(taskId)));
        QNetworkReply *reply = networkManager->put(request, jsonData);
        connect(reply, &QNetworkReply::finished, this, [this, reply]() {
            handleTaskUpdated(reply);
        });
    }
    // 暂时禁用保存按钮以防止双击
    saveButton->setEnabled(false);
}


void TaskManagerApp::handleTaskCreated(QNetworkReply *reply)
{
    reply->deleteLater();

    if (reply->error() == QNetworkReply::NoError) {
        QByteArray responseData = reply->readAll();
        QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData);

        if (!jsonDoc.isNull() && jsonDoc.isObject()) {
            QJsonObject createdTask = jsonDoc.object();
            showStatus(QString("任务 '%1' 创建成功 (ID: %2)。")
                           .arg(createdTask.value("title").toString())
                           .arg(createdTask.value("id").toInt()));
            loadTasks(); // 重新加载列表以显示新任务
            // 可选择选中新创建的任务：
            // selectTaskInList(createdTask.value("id").toInt());
        } else {
            showError("API 错误", "创建任务后接收到无效的数据格式。");
            showStatus("创建任务失败。");
            saveButton->setEnabled(true); // 失败时重新启用按钮
        }
    } else {
        handleNetworkError(reply);
        showStatus("创建任务失败。");
        saveButton->setEnabled(true); // 失败时重新启用按钮
    }
}


void TaskManagerApp::handleTaskUpdated(QNetworkReply *reply)
{
    reply->deleteLater();

    if (!selectedTaskId.has_value()) {
        qWarning() << "收到更新响应，但未选择任何任务。";
        saveButton->setEnabled(true); // 重新启用按钮
        return;
    }
    int taskId = selectedTaskId.value();


    if (reply->error() == QNetworkReply::NoError) {
        QByteArray responseData = reply->readAll();
        QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData);

        if (!jsonDoc.isNull() && jsonDoc.isObject()) {
            QJsonObject updatedTask = jsonDoc.object();
            int updatedId = updatedTask.value("id").toInt(-1);

            if (updatedId == taskId) {
                showStatus(QString("任务 ID %1 更新成功。").arg(taskId));
                tasksData.insert(taskId, updatedTask); // 更新缓存
                updateTaskItemInList(updatedTask);     // 更新列表控件中的项目
                populateForm(updatedTask);             // 使用最新数据刷新表单（例如 updated_at）
                saveButton->setEnabled(true);          // 重新启用保存按钮
                saveButton->setText("更新任务");        // 确保文本正确
                deleteButton->setEnabled(true);        // 确保删除已启用
                setFormEnabled(true);                  // 确保表单已启用
            } else {
                qWarning() << "更新的任务 ID 不匹配。预期为" << taskId << "，但获取到" << updatedId;
                // 也许重新加载任务作为后备？
                loadTasks();
            }

        } else {
            showError("API 错误", "更新任务后接收到无效的数据格式。");
            showStatus(QString("更新任务 ID: %1 失败。").arg(taskId));
            saveButton->setEnabled(true); // 失败时重新启用按钮
        }
    } else {
        handleNetworkError(reply);
        showStatus(QString("更新任务 ID: %1 失败。").arg(taskId));
        saveButton->setEnabled(true); // 失败时重新启用按钮
    }
}


void TaskManagerApp::updateTaskItemInList(const QJsonObject &task)
{
    int taskId = task.value("id").toInt(-1);
    if (taskId == -1) return;

    for (int i = 0; i < taskListWidget->count(); ++i) {
        QListWidgetItem *item = taskListWidget->item(i);
        if (item->data(Qt::UserRole).toInt() == taskId) {
            item->setText(QString("%1: %2").arg(taskId).arg(task.value("title").toString()));
            // 如果它是当前项目，请确保它保持选中状态
            if (selectedTaskId.has_value() && selectedTaskId.value() == taskId) {
                taskListWidget->setCurrentItem(item);
            }
            return; // 已找到并更新
        }
    }
    // 如果未找到（例如，在添加过滤器/搜索后），可能需要添加它或重新加载
    qWarning() << "无法在列表中找到要更新的任务 ID 的项目:" << taskId;
}


void TaskManagerApp::deleteTask()
{
    if (!selectedTaskId.has_value()) {
        showError("选择错误", "没有选中要删除的任务。");
        return;
    }

    int taskId = selectedTaskId.value();
    QString taskTitle = titleLineEdit->text(); // 从表单获取标题以进行确认

    if (taskTitle.isEmpty() && tasksData.contains(taskId)) { // 如果表单标题为空，则回退
        taskTitle = tasksData.value(taskId).value("title").toString(QString("ID %1").arg(taskId));
    } else if (taskTitle.isEmpty()) {
        taskTitle = QString("ID %1").arg(taskId);
    }


    QMessageBox::StandardButton replyButton;
    replyButton = QMessageBox::question(this, "确认删除",
                                        QString("您确定要删除任务:\n'%1' 吗？").arg(taskTitle),
                                        QMessageBox::Yes | QMessageBox::No,
                                        QMessageBox::No); // 默认为否

    if (replyButton == QMessageBox::Yes) {
        showStatus(QString("正在删除任务 ID: %1...").arg(taskId));
        deleteButton->setEnabled(false); // 删除时禁用


        QNetworkRequest request(QUrl(QString("%1/tasks/%2").arg(apiBaseUrl).arg(taskId)));
        QNetworkReply *reply = networkManager->deleteResource(request);
        connect(reply, &QNetworkReply::finished, this, [this, reply]() {
            handleTaskDeleted(reply);
        });
    }
}


void TaskManagerApp::handleTaskDeleted(QNetworkReply *reply)
{
    reply->deleteLater();
    int taskId = -1;
    // 从请求 URL 中提取任务 ID（有点脆弱，但有效）
    QString urlPath = reply->request().url().path(); // 例如 "/api/v1/tasks/123"
    QStringList parts = urlPath.split('/');
    if (parts.size() > 0) {
        bool ok;
        taskId = parts.last().toInt(&ok);
        if (!ok) taskId = -1;
    }

    // 检查 HTTP 状态代码是否成功（通常为 204 No Content 或 200 OK 表示 DELETE 成功）
    int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    bool success = (reply->error() == QNetworkReply::NoError && (statusCode >= 200 && statusCode < 300));


    if (success) {
        if (taskId != -1) {
            showStatus(QString("任务 ID %1 删除成功。").arg(taskId));
            // 从缓存和列表中高效地删除
            tasksData.remove(taskId);
            removeTaskItemFromList(taskId);
            // 如果删除的任务被选中，则清除表单
            if (selectedTaskId.has_value() && selectedTaskId.value() == taskId) {
                prepareNewTask(); // 进入“新建任务”状态
            }
        } else {
            showStatus("任务删除成功。");
            loadTasks(); // 后备：如果 ID 提取失败，则重新加载所有内容
        }

    } else {
        handleNetworkError(reply); // 显示详细错误
        if (taskId != -1) {
            showStatus(QString("删除任务 ID: %1 失败。").arg(taskId));
            // 仅当当前选定的任务仍然是失败的任务时才重新启用删除按钮
            if (selectedTaskId.has_value() && selectedTaskId.value() == taskId) {
                deleteButton->setEnabled(true);
            }
        } else {
            showStatus("删除任务失败。");
            // 如果仍然选中了任务，则可能重新启用删除按钮
            deleteButton->setEnabled(selectedTaskId.has_value());
        }
    }
}


void TaskManagerApp::removeTaskItemFromList(int taskId)
{
    for (int i = 0; i < taskListWidget->count(); ++i) {
        QListWidgetItem *item = taskListWidget->item(i);
        if (item->data(Qt::UserRole).toInt() == taskId) {
            // delete item; // 列表控件拥有所有权，删除就足够了
            taskListWidget->takeItem(i); // 删除并返回项目
            delete item; // 现在在取回所有权后显式删除项目
            return; // 已找到并删除
        }
    }
    qWarning() << "无法在列表中找到要删除的任务 ID 的项目:" << taskId;
}


void TaskManagerApp::handleNetworkError(QNetworkReply *reply)
{
    QString errorMessage = reply->errorString();
    QByteArray responseData = reply->readAll(); // 尝试读取响应正文以获取详细信息
    QString details;

    if (!responseData.isEmpty()) {
        QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData);
        if (!jsonDoc.isNull() && jsonDoc.isObject()) {
            // 查找常见的错误详细信息字段（根据您的 API 进行调整）
            if (jsonDoc.object().contains("detail")) {
                details = jsonDoc.object().value("detail").toString();
            } else if (jsonDoc.object().contains("message")) {
                details = jsonDoc.object().value("message").toString();
            } else if (jsonDoc.object().contains("error")) {
                details = jsonDoc.object().value("error").toString();
            } else {
                details = QString::fromUtf8(responseData); // 如果没有已知字段，则显示原始响应
            }
        } else {
            // 不是 JSON，显示原始响应片段
            details = QString::fromUtf8(responseData.left(200)); // 限制长度
            if (responseData.length() > 200) details += "...";
        }
    }

    int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    QString fullError = QString("网络错误 (%1): %2").arg(statusCode > 0 ? QString::number(statusCode) : "N/A").arg(errorMessage);
    if (!details.isEmpty()) {
        fullError += "\n\n详情:\n" + details;
    }

    showError("API 错误", fullError);
}


// 可选的辅助函数，用于在创建后选择项目
void TaskManagerApp::selectTaskInList(int taskId)
{
    for (int i = 0; i < taskListWidget->count(); ++i) {
        QListWidgetItem *item = taskListWidget->item(i);
        if (item->data(Qt::UserRole).toInt() == taskId) {
            taskListWidget->setCurrentItem(item); // 这会触发 onTaskSelectionChanged
            taskListWidget->scrollToItem(item); // 确保可见
            return;
        }
    }
}
